﻿/*
SINACOR - BMF&Bovespa
Arquivo: ControleMovimentoBolsa.cs
Criado em: 19-mar-2010 09:21:06
Arquiteto Responsável: p-Wgeneroso
*/
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Sinacor.Infra.UI.Authorization;
using Sinacor.Infra.Common;
using Sinacor.Infra.UI.Common;
using Sinacor.Infra.Common.Exceptions;
using Sinacor.UI.Bovespa.Movimento.Communication.Bovespa.Movimento.ControleMovimentoBolsa;
using Sinacor.UI.Bovespa.Movimento.Communication.Bovespa.Movimento.ControleMovimentoOrdens;


namespace Sinacor.UI.Bovespa.Movimento.Presenter
{
    public class ControleMovimentoBolsa : BasePresenter<IControleMovimentoBolsa>, IControleMovimento
    {
        #region Atributos
        private Communication.Calendario _communicationCalendario;
        private Communication.ControleMovimentoBolsa _communicationControleMovimentoBolsa;
        private Communication.ControleMovimentoOrdens _communicationControleMovimentoOrdens;
        private Communication.ProcessoControleMovimentoBolsa _communicationProcessoControleMovimentoBolsa;
        private Model.DataAtual _dataAtualSistema;
        private DateTime _dataMovimento;
        private DateTime _dataMovimentoD1;
        private String _mensagemSimulacao;
        private int codigoErro = 0;

        /// <summary>
        /// Informações do movimento Bolsa
        /// </summary>
        private Model.InformacoesMovimento _informacoesMovimentoBolsa;
        /// <summary>
        /// Informações do movimento de Ordens
        /// </summary>
        private Model.InformacoesMovimento _informacoesMovimentoOrdens;
        /// <summary>
        /// Indica se o módulo de Ordens está instalado.
        /// </summary>
        private bool _moduloOrdensInstalado;
        #endregion

        #region Construtor
        /// <summary>
        /// Inicializa Presenter
        /// </summary>
        /// <param name="view"></param>
        public ControleMovimentoBolsa(IControleMovimentoBolsa view)
            : base(view)
        {
            _communicationCalendario = new Communication.Calendario(this.Session);
            _communicationControleMovimentoBolsa = new Communication.ControleMovimentoBolsa(this.Session);
            _communicationControleMovimentoOrdens = new Communication.ControleMovimentoOrdens(this.Session);
            _communicationProcessoControleMovimentoBolsa = new Communication.ProcessoControleMovimentoBolsa(this.Session);
            _dataAtualSistema = new Sinacor.UI.Bovespa.Movimento.Model.DataAtual();
            _dataMovimento = new DateTime();
            _dataMovimentoD1 = new DateTime();


            _communicationProcessoControleMovimentoBolsa.AberturaConcluida += new Action<Sinacor.UI.Bovespa.Movimento.Model.ControleMovimento>(_communicationProcessoControleMovimentoBolsa_AberturaConcluida);
            _communicationProcessoControleMovimentoBolsa.ReaberturaConcluida += new Action(_communicationProcessoControleMovimentoBolsa_ReaberturaConcluida);
            _communicationProcessoControleMovimentoBolsa.ConsolidacaoConcluida += new Action(_communicationProcessoControleMovimentoBolsa_ConsolidacaoConcluida);
            _communicationProcessoControleMovimentoBolsa.SimulacaoConcluida += new Action<Sinacor.UI.Bovespa.Movimento.Model.MensagemSimulacao>(_communicationProcessoControleMovimentoBolsa_SimulacaoConcluida);
            _communicationProcessoControleMovimentoBolsa.FechamentoConcluido += new Action<Sinacor.UI.Bovespa.Movimento.Model.MensagemFechamento>(_communicationProcessoControleMovimentoBolsa_FechamentoConcluido);
            _communicationProcessoControleMovimentoBolsa.CommunicationError += new EventHandler<CommunicationErrorEventArgs>(_communicationProcessoControleMovimentoBolsa_CommunicationError);
            //1.Criar a instancia da Communication.
            //ProcessoControleMovimentoBolsa
            //(_communicationProcessoControleMovimento
            //Bolsa)
            //2. Assinar os eventos da communication
            //conrforme abaixo:
            //* AberturaConcluida
            //* ReaberturaConcluida
            //* ConsolidacaoConcluida
            //* SimulacaoConcluida
            //* FechamentoConcluido
            //* CommunicationError
            //
            //3. Criar a instancia da Communication.
            //ControleMovimentoBolsa
            //(_communicationControleMovimentoBolsa)

        }
        #endregion

        #region Propriedades
        /// <summary>
        /// Armazena a data atual, recuperada do banco de dados
        /// Fazer o binding com o campo data atual da tela.
        /// </summary>
        public Model.DataAtual DataAtualSistema
        {
            get { return _dataAtualSistema; }
            set { _dataAtualSistema = value; }
        }

        /// <summary>
        /// Armazena a data do movimento D0.
        /// Realizar binding com o campo Data do Movimento da tela.
        /// </summary>
        public DateTime DataMovimento
        {
            get { return _dataMovimento; }
            set { _dataMovimento = value; }
        }

        /// <summary>
        /// próxima data do movimento calculada
        /// Realizar binding com a campo Data do Movimento D+1 da tela
        /// </summary>
        public DateTime DataMovimentoD1
        {
            get { return _dataMovimentoD1; }
            set { _dataMovimentoD1 = value; }
        }


        #endregion
        #region Métodos
        public override void Dispose()
        {
            try
            {
                _communicationProcessoControleMovimentoBolsa.Disconnect();
            }
            catch (Exception ex)
            {
                base.HandleException(ex);
            }
            //Consumir o método Communication.
            //ProcessoControleMovimentoBolsa.
            //Disconnect()
        }

        /// <summary>
        /// Assinatura do método AberturaConcluida da communication
        /// </summary>
        /// <param name="obj"></param>
        private void _communicationProcessoControleMovimentoBolsa_AberturaConcluida(Model.ControleMovimento obj)
        {
            try
            {
                this.View.FecharAguarde();
                this.View.InformarMovimentoAberto();
                this.View.FecharTela();
            }
            catch (Exception ex)
            {
                base.HandleException(ex);
            }
            //1. Consumir o método View.
            //FecharAguarde();
            //2. Consumir o método View.
            //InformarMovimentoAberto();
            //3. Consumir o método View.FecharTela().            
        }

        /// <summary>
        /// Assinatura do método CommunicationError da communication
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void _communicationProcessoControleMovimentoBolsa_CommunicationError(object sender, CommunicationErrorEventArgs e)
        {
            
            this.View.FecharAguarde();

            if ((e.Exception is BusinessException) || (e.Exception is ValidationException))
            {
                this.View.AtualizarErrosServico();
                this.HandleException(e.Exception);
            }
            else
            {
                this.View.InformarErroInesperado();
            }

            //1. Consumir o método View.
            //FecharAguarde()
            //
            //2. Verificar se o tipo de exceção
            //enviada é BusinessException ou
            //ValidationException
            //
            //Se excecao é BusinessException .OU.
            //excecao é ValidationException
            //   Consumir o método HandleException()
            //informando no parametro a exceção
            //enviada.
            //SeNao
            //   Consumir o método View.
            //InformarErroInesperado()
            //FimSe

        }

        /// <summary>
        /// Assinatura do método ConsolidacaoConcluida da communication
        /// </summary>
        private void _communicationProcessoControleMovimentoBolsa_ConsolidacaoConcluida()
        {
            try
            {
                this.View.FecharAguarde();
                this.View.InformarMovimentoConsolidado();
                this.View.FecharTela();
            }
            catch (Exception ex)
            {
                base.HandleException(ex);
            }

            //1. Consumir o método View.
            //FecharAguarde()
            //2. Consumir o método View.
            //InformarMovimentoConsolidado()
            //3. Consumir o método View.FecharTela()			
        }

        /// <summary>
        /// Assinatura do método FechamentoConcluido da communication
        /// </summary>
        /// <param name="obj"></param>
        private void _communicationProcessoControleMovimentoBolsa_FechamentoConcluido(Model.MensagemFechamento obj)
        {
            try
            {

                this.View.FecharAguarde();
                if (obj.Sucesso)
                {
                    this.View.InformarFechamentoConcluido();
                    this.View.FecharTela();
                }
                else
                {
                    _mensagemSimulacao = this.ConcatenarMensagensSimulacao(obj.MensagemSimulacao);
                    if (this.View.ConfirmarContinuacaoFechamento(_mensagemSimulacao))
                    {
                        this.View.AbrirAguarde();

                        System.Threading.Thread.Sleep(10000);

                        this.FecharMovimento(true);
                    }
                }
            }
            catch (Exception ex)
            {
                base.HandleException(ex);
            }

            //1. Consumir o método View.
            //FecharAguarde()
            //
            //2. Verificar se o fechamento foi
            //processado com sucesso
            //
            //Se obj.Sucesso igual a verdadeiro
            // 1. Consumir o método View.
            //InformarFechamentoConcluido()
            // 2. Consumir o método View.FecharTela()
            //SeNao
            //
            // 1. Consumir o método
            //ConcatenarMensagensSimulacao()
            //informando no parametro a model
            //"MensagemSimulacao", representada pela
            //propriedade "MensageSimulacao" da model
            //"MensagemFechamento" enviada no
            //parametro, e armazenar o retorno em
            //variavel local.
            // 2. Consumir o método View.
            //ConfirmarContinuacaoFechamento()
            //informando no parametro o retorno da
            //ação anterior.
            //
            // Se o retorno da ação anterior for
            //igual a verdadeiro
            //     Consumir o método
            //FecharMovimento() informando no
            //parametro o valor "true" (verdadeiro).
            // FimSe
            //
            //FimSe          
        }

        /// <summary>
        /// Assinatura do método ReaberturaConcluida da communication
        /// </summary>
        private void _communicationProcessoControleMovimentoBolsa_ReaberturaConcluida()
        {
            try
            {
                this.View.FecharAguarde();
                this.View.InformarMovimentoAberto();
                this.View.FecharTela();
            }
            catch (Exception ex)
            {
                base.HandleException(ex);
            }

            //1. Consumir o método View.
            //FecharAguarde().
            //2. Consumir o método View.
            //InformarMovimentoAberto();
            //3. Consumir o método View.FecharTela()           
        }

        /// <summary>
        /// Assinatura do método SimulacaoConcluida da communication
        /// </summary>
        /// <param name="obj"></param>
        private void _communicationProcessoControleMovimentoBolsa_SimulacaoConcluida(Model.MensagemSimulacao obj)
        {
            try
            {
                this.View.FecharAguarde();

                if (obj.Sucesso)
                {
                    this.View.InformarSimulacaoConcluida();
                    this.View.FecharTela();
                }
                else
                {
                    String retorno;
                    retorno = this.ConcatenarMensagensSimulacao(obj);
                    if (this.View.ConfirmarContinuacaoFechamento(retorno))
                    {
                        this.SimularFechamento(true);
                    }
                }
            }
            catch (Exception ex)
            {
                base.HandleException(ex);
            }

            //1. Consumir o método View.
            //FecharAguarde()
            //
            //2. Verificar se a simulação processou
            //com sucesso
            //
            //Se obj.Sucesso igual a verdadeiro
            // 1. Consumir o método View.
            //InformarSimulacaoConcluida()
            // 2. Consumir o método View.
            //FecharAguarde()
            //SeNao
            //
            // 1. Consumir o método
            //ConcatenarMensagensSimulacao()
            //informando no parametro a model
            //"MensagemSimulacao" enviada e armazenar
            //o retorno em variavel local.
            // 2. Consumir o método View.
            //ConfirmarContinuacaoFechamento()
            //informando no parametro o retorno da
            //ação anterior.
            //
            // Se o retorno da ação anterior for
            //igual a verdadeiro
            //     Consumir o método
            //SimularFechamento() informando no
            //parametro o valor "true" (verdadeiro).
            // FimSe
            //
            //FimSe
        }

        /// <summary>
        /// Abre o movimento bolsa
        /// </summary>
        public void AbrirMovimento()
        {
            try
            {
                this.View.AbrirAguarde();

                if (this.View.ConfirmarAberturaMovimento())
                {
                    this.View.AbrirAguarde();
                    _communicationProcessoControleMovimentoBolsa.AbrirMovimento();
                }
                else
                {
                    this.View.InformarAberturaNaoEfetuada();
                }
            }
            catch (Exception ex)
            {
                this.View.FecharAguarde();
                base.HandleException(ex);
            }

            //Confirmar com o usuário a abertura do
            //movimento consumindo o método View.
            //ConfirmarAberturaMovimento()
            //
            //Se usuário confirmou
            // 1. Consumir o método View.
            //AbrirAguarde()
            // 2. Consumir o método Communication.
            //ProcessControleMovimentoBolsa.
            //AbrirMovimento()
            //SeNao
            // Consumir o método View.
            //InformarAberturaNaoEfetuada()
            //FimSe
        }

        /// <summary>
        /// Carrega os dados básicos necessários para ajustar a tela conforme o movimento.
        /// </summary>
        private void CarregarDadosBasicos()
        {
            try
            {
                _informacoesMovimentoBolsa = new Sinacor.UI.Bovespa.Movimento.Model.InformacoesMovimento();
                DataAtualSistema = this._communicationCalendario.ObterDataAtual();
                Model.DataMovimento data = new Sinacor.UI.Bovespa.Movimento.Model.DataMovimento();
                _informacoesMovimentoBolsa = _communicationControleMovimentoBolsa.ObterInformacoesMovimento(data);
                DataMovimento = _informacoesMovimentoBolsa.DataMovimento;
                DataMovimentoD1 = _communicationControleMovimentoBolsa.CalcularDataAberturaMovimento().Valor;

                _moduloOrdensInstalado = (new Sinacor.UI.Bovespa.Movimento.Communication.Acesso(this.Session)).VerificarSistemaInstalado("ORD");

                if(_moduloOrdensInstalado)
                    _informacoesMovimentoOrdens = _communicationControleMovimentoOrdens.ObterInformacoesMovimento(data);

                 View.AtualizarDatas();
                
            }
            catch (Exception ex)
            {
                base.HandleException(ex);
            }

            //Verificar diagrama de atividades
            //ControleMovimentoBolsa.
            //CarregarDadosBasicos()            
        }

        /// <summary>
        /// Concatena as mensagens de simulação retornadas no processo.
        /// </summary>
        /// <param name="model"></param>
        private string ConcatenarMensagensSimulacao(Model.MensagemSimulacao model)
        {
            StringBuilder mensagens = new StringBuilder();
            try
            {
                foreach (Model.Enum.TipoConsistencia item in model.Inconsistencias)
                {
                    switch (item)
                    {
                        case Model.Enum.TipoConsistencia.ALC:
                            // Adicionar na "string" a mensagem da
                            //ResourceKey "Bovespa.Movimento.Message.ConsistALC" + <enter>  
                            mensagens.AppendLine(this.View.RetornarMensagemExibicaoFormatada("Bovespa.Movimento.Message.ConsistALC"));
                            break;
                        case Model.Enum.TipoConsistencia.CI:

                            //dicionar na "string" a mensagem da
                            //ResourceKey "Bovespa.Movimento.Message.ConsistenciaCI" + <enter>
                            mensagens.AppendLine(this.View.RetornarMensagemExibicaoFormatada("Bovespa.Movimento.Message.ConsistenciaCI"));
                            break;

                        case Model.Enum.TipoConsistencia.CLI:
                            // Adicionar na "string" a mensagem da
                            //ResourceKey "Bovespa.Movimento.Message.ConsistCLI" + <enter>
                            mensagens.AppendLine(this.View.RetornarMensagemExibicaoFormatada("Bovespa.Movimento.Message.ConsistCLI"));
                            break;

                        case Model.Enum.TipoConsistencia.FEC:
                            // Adicionar na "string" a mensagem da
                            //ResourceKey "Bovespa.Movimento.Message.ConsistFEC" + <enter>
                            mensagens.AppendLine(this.View.RetornarMensagemExibicaoFormatada("Bovespa.Movimento.Message.ConsistFEC"));
                            break;

                        case Model.Enum.TipoConsistencia.JUS:
                            // Adicionar na "string" a mensagem da
                            //ResourceKey "Bovespa.Movimento.Message.ConsistJUS" + <enter>
                            mensagens.AppendLine(this.View.RetornarMensagemExibicaoFormatada("Bovespa.Movimento.Message.ConsistJUS"));
                            break;

                        case Model.Enum.TipoConsistencia.TER:
                            // Adicionar na "string" a mensagem da
                            //ResourceKey "Bovespa.Movimento.Message.ConsistTER" + <enter>
                            mensagens.AppendLine(this.View.RetornarMensagemExibicaoFormatada("Bovespa.Movimento.Message.ConsistTER"));
                            break;

                        default:
                            // Adicionar na "string" a mensagem da
                            //ResourceKey "Bovespa.Movimento.Message.NegEspecIncompleta" + <enter>
                            mensagens.AppendLine(this.View.RetornarMensagemExibicaoFormatada("Bovespa.Movimento.Message.NegEspecIncompleta"));
                            break;
                    }
                }
            }
            catch (Exception ex)
            {
                base.HandleException(ex);
            }

            return mensagens.ToString();

            //Concatenar as mensagens de
            //inconsistências, contidas na
            //propriedade "Inconsistencias" da
            //mensagem enviada no parametro,
            //adicionando ao final de cada mensagem
            //um caracter de quebra de linha e
            //retornar as mensagens no método. As
            //mensagens estão descritas nas
            //ResourceKeys conforme critérios abaixo:
            //
            //Se tipoConsistencia == Enum.
            //TipoConsistencia.CI
            // Adicionar na "string" a mensagem da
            //ResourceKey "Bovespa.Movimento.Message.
            //ConsistenciaCI" + <enter>

            //Se tipoConsistencia == Enum.
            //TipoConsistencia.ALC
            // Adicionar na "string" a mensagem da
            //ResourceKey "Bovespa.Movimento.Message.
            //ConsistALC" + <enter>

            //Se tipoConsistencia == Enum.
            //TipoConsistencia.JUS
            // Adicionar na "string" a mensagem da
            //ResourceKey "Bovespa.Movimento.Message.
            //ConsistJUS" + <enter>

            //Se tipoConsistencia == Enum.
            //TipoConsistencia.CLI
            // Adicionar na "string" a mensagem da
            //ResourceKey "Bovespa.Movimento.Message.
            //ConsistCLI" + <enter>

            //Se tipoConsistencia == Enum.
            //TipoConsistencia.TER
            // Adicionar na "string" a mensagem da
            //ResourceKey "Bovespa.Movimento.Message.
            //ConsistTER" + <enter>

            //Se tipoConsistencia == Enum.
            //TipoConsistencia.FEC
            // Adicionar na "string" a mensagem da
            //ResourceKey "Bovespa.Movimento.Message.
            //ConsistFEC" + <enter>

            //SeNao
            // Adicionar na "string" a mensagem da
            //ResourceKey "Bovespa.Movimento.Message.
            //NegEspecIncompleta" + <enter>

            //FimSe
            //
            //Exemplo:
            //
            //StringBuilder mensagens = new
            //StringBuilder();
            //foreach(TipoConsistencia
            //tipoConsistencia in model.
            //Inconsistencias)
            //{
            //  if(tipoConsistencia == Enum.
            //TipoConsistencia.CI)
            //      mensagens.Add(string.
            //Format("{0}\n", FindResource("Bovespa.
            //Movimento.Message.ConsistenciaCI")));
            // else if(...)
            // ...
            //}
            //return mensagens.ToString();
        }

        /// <summary>
        /// Consolida o movimento bolsa
        /// </summary>
        public void ConsolidarMovimento()
        {
            try
            {
                this.View.AbrirAguarde();

                if (this.View.ConfirmarConsolidacaoMovimento())
                {
                    this.View.AbrirAguarde();
                    Model.Parameter.FiltroControleMovimento filtro = new Model.Parameter.FiltroControleMovimento();
                    filtro.DataMovimento = this.DataMovimento;
                    _communicationProcessoControleMovimentoBolsa.ConsolidarFechamento(filtro);
                }
                else
                {
                    this.View.InformarConsolidacaoNaoEfetuada();
                }
            }
            catch (Exception ex)
            {
                this.View.FecharAguarde();
                base.HandleException(ex);
            }

            //Confirmar com o usuário a execução da
            //consolidação consumindo o método View.
            //ConfirmaConsolidacaoMovimento()
            //
            //Se usuário confirmou
            //
            // 1. Consumir o método View.
            //AbrirAguarde()
            // 2. Consumir o método Communication.
            //ProcessControleMovimentoBolsa.
            //ConsolidarMovimento() informando no
            //parametro a data do movimento
            //representado pela propriedade
            //"DataMovimento"
            //
            //SeNao
            //
            // Consumir o método View.
            //InformarConsolidacaoNaoEfetuada()
            //
            //FimSe         
        }

        /// <summary>
        /// Fecha o movimento
        /// </summary>
        /// <param name="continuaSeInconsistente"></param>
        public void FecharMovimento(bool continuaSeInconsistente)
        {
            try
            {
                //while (_communicationProcessoControleMovimentoBolsa.IsProcessRunning())
                //    System.Threading.Thread.Sleep(1000);

                Model.Parameter.FiltroFechamentoMovimento filtro = new Model.Parameter.FiltroFechamentoMovimento();
                filtro.DataMovimento = this.DataMovimento;
                filtro.ProcessaComInconsistencia = continuaSeInconsistente;
                //Limpando o Communication do processs
                _communicationProcessoControleMovimentoBolsa.AberturaConcluida -= new Action<Sinacor.UI.Bovespa.Movimento.Model.ControleMovimento>(_communicationProcessoControleMovimentoBolsa_AberturaConcluida);
                _communicationProcessoControleMovimentoBolsa.ReaberturaConcluida -= new Action(_communicationProcessoControleMovimentoBolsa_ReaberturaConcluida);
                _communicationProcessoControleMovimentoBolsa.ConsolidacaoConcluida -= new Action(_communicationProcessoControleMovimentoBolsa_ConsolidacaoConcluida);
                _communicationProcessoControleMovimentoBolsa.SimulacaoConcluida -= new Action<Sinacor.UI.Bovespa.Movimento.Model.MensagemSimulacao>(_communicationProcessoControleMovimentoBolsa_SimulacaoConcluida);
                _communicationProcessoControleMovimentoBolsa.FechamentoConcluido -= new Action<Sinacor.UI.Bovespa.Movimento.Model.MensagemFechamento>(_communicationProcessoControleMovimentoBolsa_FechamentoConcluido);
                _communicationProcessoControleMovimentoBolsa.CommunicationError -= new EventHandler<CommunicationErrorEventArgs>(_communicationProcessoControleMovimentoBolsa_CommunicationError);

                //instancia nova sessão
                _communicationProcessoControleMovimentoBolsa = new Communication.ProcessoControleMovimentoBolsa(this.Session);

                //instancia os métodos
                _communicationProcessoControleMovimentoBolsa.AberturaConcluida += new Action<Sinacor.UI.Bovespa.Movimento.Model.ControleMovimento>(_communicationProcessoControleMovimentoBolsa_AberturaConcluida);
                _communicationProcessoControleMovimentoBolsa.ReaberturaConcluida += new Action(_communicationProcessoControleMovimentoBolsa_ReaberturaConcluida);
                _communicationProcessoControleMovimentoBolsa.ConsolidacaoConcluida += new Action(_communicationProcessoControleMovimentoBolsa_ConsolidacaoConcluida);
                _communicationProcessoControleMovimentoBolsa.SimulacaoConcluida += new Action<Sinacor.UI.Bovespa.Movimento.Model.MensagemSimulacao>(_communicationProcessoControleMovimentoBolsa_SimulacaoConcluida);
                _communicationProcessoControleMovimentoBolsa.FechamentoConcluido += new Action<Sinacor.UI.Bovespa.Movimento.Model.MensagemFechamento>(_communicationProcessoControleMovimentoBolsa_FechamentoConcluido);
                _communicationProcessoControleMovimentoBolsa.CommunicationError += new EventHandler<CommunicationErrorEventArgs>(_communicationProcessoControleMovimentoBolsa_CommunicationError);
                _communicationProcessoControleMovimentoBolsa.FecharMovimento(filtro);
            }
            catch (Exception ex)
            {
                base.HandleException(ex);
            }

            //1. Consumir o método View.
            //AbrirAguarde()
            //2. Consumir o método Communication.
            //ProcessoControleMovimentoBolsa.
            //FecharMovimento() informando no filtro
            //a data do movimento, representado pela
            //propriedade "DataMovimento", e o
            //indicador de continuidade do processo
            //em caso de inconsistencia
            //(FiltroFechamentoMovimento.
            //ProcessaComInconsistencia) conforme o
            //valor do parametro
            //"continuaSeInconsistente" enviado.

        }

        /// <summary>
        /// Fecha o movimento bolsa
        /// </summary>
        public void FecharMovimento()
        {
            try
            {
                this.View.AbrirAguarde();

                if (this.View.ConfirmarFechamentoMovimento())
                {
                    this.FecharMovimento(false);
                }
                else
                {
                    this.View.InformarFechamentoNaoEfetuado();
                }
            }
            catch (Exception ex)
            {
                this.View.FecharAguarde();
                base.HandleException(ex);
            }


            //Confirmar com o usuário o fechamento do
            //movimento consumir o método View.
            //ConfirmarFechamentoMovimento()
            //
            //Se usuário confirmou
            // Consumir o método FecharMovimento()
            //informando no parametro o valor "false"
            //(falso).
            //SeNao
            // Consumir o método View.
            //InformarFechamentoNaoEfetuado()
            //FimSe            
        }

        /// <summary>
        /// Inicializa a tela
        /// </summary>
        public void Inicializar()
        {
            try
            {
                this.CarregarDadosBasicos();
                this.View.InicializarObjetosMovimentoBolsa();
                if (_informacoesMovimentoBolsa.EstadoMovimento == Model.Enum.TipoMovimento.AtualizandoVersao)
                {
                    this.View.PrepararTelaAberturaD1();
                }
                else if (this.VerificarEstadoAbertura())
                {
                    this.View.PrepararTelaAbertura();
                }
                else if (this.VerificarEstadoReabertura())
                {
                    this.View.PrepararTelaReabertura();
                }
                else if (this.VerificarEstadoFechamento())
                {
                    this.View.PrepararTelaFechamento();
                }
                else if (this.VerificarEstadoConsolidacao())
                {
                    this.View.PrepararTelaConsolidacao();
                }
            }
            catch (Exception ex)
            {
                base.HandleException(ex);
            }

            //Verificar diagrama de atividades
            //ControleMovimentoBolsa.Inicializar()



        }

        /// <summary>
        /// Reabre o movimento Bolsa
        /// </summary>
        public void ReabrirMovimento()
        {
            try
            {
                this.View.AbrirAguarde();

                if (this.View.ConfirmarReaberturaMovimento())
                {
                    this.View.AbrirAguarde();
                    Model.Parameter.FiltroControleMovimento filtro = new Model.Parameter.FiltroControleMovimento();
                    filtro.DataMovimento = this.DataMovimento;
                    _communicationProcessoControleMovimentoBolsa.ReabrirMovimento(filtro);
                }
                else
                {
                    this.View.InformarReaberturaNaoEfetuada();
                }
            }
            catch (Exception ex)
            {
                this.View.FecharAguarde();
                base.HandleException(ex);
            }

            //Confirmar com o usuário a reabertura do
            //movimento consumindo o método View.
            //ConfirmarReaberturaMovimento()
            //
            //Se usuário confirmou
            //
            // 1. Consumir o método View.
            //AbrirAguarde();
            // 2. Consumir o método Communication.
            //ProcessControleMovimentoBolsa.
            //ReabrirMovimento() informando no
            //parametro a data do movimento
            //representado pela propriedade
            //"DataMovimento"
            //
            //SeNao
            // Consumir o método View.
            //InformarReaberturaNaoEfetuada()
            //FimSe            
        }

        /// <summary>
        /// Sai da tela de controle movimento bolsa
        /// </summary>
        public void Sair()
        {
            try
            {
                if (this.View.ConfirmarSaida())
                {
                    this.View.FecharTela();
                }
            }
            catch (Exception ex)
            {
                base.HandleException(ex);
            }

            //Confirmar com o usuário se deseja sair,
            //consumindo o método View.
            //ConfirmarSaida()
            //
            //Se o usuário confirmou a saida
            // Consumir o método View.FecharTela()
            //FimSe           
        }

        /// <summary>
        /// Simula o fechamento do movimento bolsa
        /// </summary>
        /// <param name="continuaSeInconsistente"></param>
        private void SimularFechamento(bool continuaSeInconsistente)
        {
            try
            {
                this.View.AbrirAguarde();

                Model.Parameter.FiltroFechamentoMovimento filtro = new Model.Parameter.FiltroFechamentoMovimento();
                filtro.DataMovimento = this.DataMovimento;
                filtro.ProcessaComInconsistencia = continuaSeInconsistente;
                Communication.ProcessoControleMovimentoBolsa communication = new Communication.ProcessoControleMovimentoBolsa(this.Session);
                communication.SimulacaoConcluida += new Action<Sinacor.UI.Bovespa.Movimento.Model.MensagemSimulacao>(_communicationProcessoControleMovimentoBolsa_SimulacaoConcluida);
                communication.CommunicationError += new EventHandler<CommunicationErrorEventArgs>(_communicationProcessoControleMovimentoBolsa_CommunicationError);
                communication.SimularFechamento(filtro);
            }
            catch (Exception ex)
            {
                this.View.FecharAguarde();
                base.HandleException(ex);
            }
            //1. Consumir o método View.
            //AbrirAguarde()
            //2. Consumir o método Communication.
            //ProcessoControleMovimentoBolsa.
            //SimularFechamento() informando no
            //filtro a data do movimento,
            //representado pela propriedade
            //"DataMovimento", e o indicador de
            //continuidade do processo em caso de
            //inconsistencia
            //(FiltroFechamentoMovimento.
            //ProcessaComInconsistencia) conforme o
            //valor do parametro
            //"continuaSeInconsistente" enviado.

        }

        /// <summary>
        /// Simula o fechamento do movimento bolsa.
        /// </summary>
        public void SimularFechamentoMovimento()
        {
            try
            {
                if (this.View.ConfirmarSimulacaoFechamento())
                {                    
                    this.SimularFechamento(false);
                }
                else
                {
                    this.View.InformarSimulacaoNaoEfetuada();
                }
            }
            catch (Exception ex)
            {
                base.HandleException(ex);
            }


            //Confirmar com o usuário a simulação do
            //fechamento consumindo o método View.
            //ConfirmarSimulacaoFechamento()
            //
            //Se usuário confirmou
            // Consumir o método SimularFechamento()
            //informando no parametro o valor "false"
            //(falso).
            //SeNao
            // Consumir o método View.
            //InformarSimulacaoNaoEfetuada()
            //FimSe
        }

        /// <summary>
        /// Verificar se o estado do movimento está para Abertura.
        /// </summary>
        private bool VerificarEstadoAbertura()
        {
            try
            {
                if (_moduloOrdensInstalado)
                {
                    if (_informacoesMovimentoBolsa.EstadoMovimento == Model.Enum.TipoMovimento.Fechamento &&
                        _informacoesMovimentoOrdens.EstadoMovimento == Model.Enum.TipoMovimento.Abertura)
                    {
                        return true;
                    }
                    else
                    {
                        if (_informacoesMovimentoBolsa.EstadoMovimento == Model.Enum.TipoMovimento.Fechamento &&
                            _informacoesMovimentoOrdens.EstadoMovimento == Model.Enum.TipoMovimento.Fechamento &&
                            _informacoesMovimentoOrdens.DataMovimento > _informacoesMovimentoBolsa.DataMovimento)
                        {
                            return true;
                        }
                        else
                        {
                            return false;
                        }
                    }
                }
                else
                {
                    if (_informacoesMovimentoBolsa.EstadoMovimento == Model.Enum.TipoMovimento.Fechamento)
                    {
                        return true;
                    }
                    else
                    {
                        return false;
                    }
                }
            }
            catch (Exception ex)
            {
                base.HandleException(ex);
                return false;
            }

            //Verificar diagrama de atividade
            //ControleMovimentoBolsa.
            //VerificarEstadoAbertura()          
        }

        /// <summary>
        /// Verificar se o estado do movimento está para Consolidação
        /// </summary>
        private bool VerificarEstadoConsolidacao()
        {
            try
            {
                if (_moduloOrdensInstalado)
                {
                    if (_informacoesMovimentoBolsa.EstadoMovimento == Model.Enum.TipoMovimento.Abertura)
                    {
                        return true;
                    }
                    else
                    {
                        return false;
                    }
                }
                else
                {
                    return false;
                }
            }
            catch (Exception ex)
            {
                base.HandleException(ex);
                return false;
            }

            //Verificar diagrama de atividade
            //ControleMovimentoBolsa.
            //VerificarEstadoConsolidacao()
        }

        /// <summary>
        /// Verificar se o estado do movimento está para Fechamento
        /// </summary>
        private bool VerificarEstadoFechamento()
        {
            try
            {
                if (_moduloOrdensInstalado)
                {
                    if (_informacoesMovimentoBolsa.EstadoMovimento == Model.Enum.TipoMovimento.Abertura &&
                        _informacoesMovimentoOrdens.EstadoMovimento == Model.Enum.TipoMovimento.Fechamento)
                    {
                        return true;
                    }
                    else
                    {
                        if (_informacoesMovimentoBolsa.EstadoMovimento == Model.Enum.TipoMovimento.Abertura &&
                            _informacoesMovimentoOrdens.EstadoMovimento == Model.Enum.TipoMovimento.Abertura &&
                            _informacoesMovimentoOrdens.DataMovimento > _informacoesMovimentoBolsa.DataMovimento)
                        {
                            return true;
                        }
                        else
                        {
                            return false;
                        }
                    }
                }
                else
                {
                    if (_informacoesMovimentoBolsa.EstadoMovimento == Model.Enum.TipoMovimento.Abertura)
                    {
                        return true;
                    }
                    else
                    {
                        return false;
                    }
                }
            }
            catch (Exception ex)
            {
                base.HandleException(ex);
                return false;
            }
            //Verificar diagrama de atividades
            //ControleMovimentoBolsa.
            //VerificarEstadoFechamento()
        }

        /// <summary>
        /// Verifica se o estado do movimento está para Reabertura
        /// </summary>
        private bool VerificarEstadoReabertura()
        {
            try
            {
                if (_moduloOrdensInstalado)
                {
                    if (_informacoesMovimentoBolsa.EstadoMovimento == Model.Enum.TipoMovimento.ProcessoFechamento)
                    {
                        return true;
                    }
                    else
                    {
                        if (_informacoesMovimentoBolsa.EstadoMovimento == Model.Enum.TipoMovimento.Fechamento &&
                            _informacoesMovimentoOrdens.EstadoMovimento == Model.Enum.TipoMovimento.Fechamento &&
                            _informacoesMovimentoOrdens.DataMovimento == _informacoesMovimentoBolsa.DataMovimento)
                        {
                            return true;
                        }
                        else
                        {
                            return false;
                        }
                    }

                }
                else
                {
                    if (_informacoesMovimentoBolsa.EstadoMovimento == Model.Enum.TipoMovimento.ProcessoFechamento)
                    {
                        return true;
                    }
                    else
                    {
                        return false;
                    }
                }
            }
            catch (Exception ex)
            {
                base.HandleException(ex);
                return false;
            }

            //Verificar diagrama de atividades
            //ControleMovimentoBolsa.
            //VerificarEstadoReabertura()
        }
        #endregion
    }

}